Skip to content

fix(fsx): copyTo copies the whole file and leaves the offset - #10

Merged
HaoZeke merged 20 commits into
mainfrom
fix/copy-offset
Nov 16, 2026
Merged

HaoZeke merged 20 commits into
mainfrom
fix/copy-offset

Conversation

@HaoZeke

@HaoZeke HaoZeke commented Nov 16, 2026

Copy link
Copy Markdown
Contributor

fsx.copyTo now copies the whole source, whatever the descriptor's offset, and leaves the offset where it was.

  • copyTo's doc promises a cp(1) copy of an open file, but copyFd read from the current offset and left it at the end of the file. A caller that read the first line got a copy without it.
  • copyFd now reads with pread from byte 0, so the copy is whole and the caller's offset is left alone. eb-keep-logs, the one caller, rewinds the source after the copy, which now does nothing; its tests pass against this change.
  • The test reads a header first, then expects the whole file in the copy and the offset where the read left it.

Conflicts with #3 (fix/safety) in src/fsx.zig; whichever lands second needs a rebase.

The branch has a CHANGELOG Unreleased entry.

fgetxattr was not retried on EINTR, so a signal refused the replacement.
atomicWrite also leaked the temporary path, the step names and the spare
ACL read. Tests cover both under std.testing.allocator.
copyTo renames the new bytes into place, so a full disk or a file-size
limit leaves an existing file unchanged. appendLine rolls a short write
back to the size before it, so the line list does not gain a partial line.
lockExclusive reads its deadline from the monotonic clock, so a signal
that cuts a sleep short does not expire the wait. RootLock refuses a gate
or sidecar that is not a regular file of this user with one link.
decodeCache and key comparison read past a string that ended on a
backslash. They now return an encoding error, and the bytes allocated
before that error are freed.
The list was abandoned on the error path, and the slice it returned was
not the whole allocation, so a caller could not free it.
The archive is written under a temporary name, synced and renamed. A
crash or a short write no longer leaves a partial name.gz that a later
run skips.
groupAlive treated EINTR from getdents as "nobody is alive", so
waitGroupGone could return while the group was still running.
COMPAT.md said errno 134 was the unnamed hardware-error text. On x86_64
that text is errno 133, HWPOISON, which Zig names; 134 is unnamed, as
glibc prints it. The module summary matches the copy and the lock gate.
A caller started with fd 0, 1 or 2 closed gets /dev/null at that number.
With fd 1 closed the child's stderr ends up in the captured stdout; with
fd 0 or 2 closed the child loses that stream at exec. Each test forks,
closes the descriptor and checks what the child sees. They fail until
childExec is fixed.
…reams

When the caller started with fd 0, 1 or 2 closed, /dev/null or a pipe took
that number, and childExec's dup2 sequence either clobbered it (fd 1: the
child's stderr went to the captured stdout) or made a no-op dup2 onto
itself that kept close-on-exec (fd 0 or 2: the child started with that
stream closed). Sources below 3 now move above 2 before the dup2s, as
Python's _posixsubprocess does.
With SIGCHLD set to SIG_IGN the kernel reaps the child itself and wait4
fails with ECHILD. reap reports that as a kill by signal 9, so a child
that exited 3 reads as SIGKILLed. The test expects error.NoChild and
fails until reap returns the wait4 error.
reap turned any wait4 failure into a kill by signal 9. With SIGCHLD
ignored the kernel reaps the child and wait4 fails with ECHILD, so run
reported a SIGKILL for a child that exited normally. reap now returns the
wait4 error through sys.call, run returns error.NoChild with
sys.last_errno set, and run's doc says not to ignore SIGCHLD. The error
paths still reap and keep their own error.
decodeCache("abc\\") and decodeWire("\\u12") index past the string and
panic, as does a key lookup on a key that ends in a backslash. The
decoders also take "\\u+123" (parseInt allows a sign) and read
"\\x0041" as a \u escape. The test expects error.Encoding under
std.testing.allocator, so nothing allocated before the error may leak.
codePoints read raw[i + 1] and the four \u digits without a bounds
check, so a string ending in a backslash or a short \u escape panicked.
It also handed any unknown escape to the \u branch and parsed the digits
with parseInt, which accepts a sign. Escapes are now checked: a cut-off,
unknown or non-hex escape is error.Encoding. keyEql gets the same bounds
check. The decoders free their scratch and partial output on error, and
return exact-length slices.
json.loads keeps 18446744073709551616 as an exact int. toPy falls back to
parseFloat when parseInt overflows, so it becomes the float
18446744073709552000 and dumps writes it back as 1.8446744073709552e+19.
The test expects an error, and checks that the i64 bounds and float-shaped
numbers still read as before.
toPy tried parseInt and fell back to parseFloat on any failure, so an
integer that overflows i64 came back as a float and changed type and
digits. The JSON text's shape now decides: no fraction or exponent is an
int, and one that does not fit is error.Encoding, which toPy already
returns for a value it cannot represent. The error set is unchanged.
The depth check runs on every value at depth > 32. An empty container at
depth 32 has no value inside it to check, so 33 nested empty arrays parse
while 33 arrays around a scalar do not. The test pins one limit for
both: 32 nested arrays or objects. It fails until the check runs on
entering a container.
The depth check ran at the top of every value, so an empty container at
depth 32 passed and the limit was 33 for empty containers but 32 around a
scalar. It now runs on entering an array or object: at most 32 nested
containers, now the public json.max_depth, documented at parse. The
module doc still described one guard's JSON. It now names what the
module holds: the parser, the cache and wire codecs, toPy, and dumps.
copyTo says it copies an open file as cp(1) does, but copyFd read from
the descriptor's offset and left it at the end. A caller that read the
first line got a copy without it. The test reads a header first, then
expects the whole file in the copy and the offset where the read left it.
copyTo's doc promises a cp(1) copy of an open file, but copyFd read from
the current offset and left it at the end of the file. copyFd now reads
with pread from byte 0, so the copy is whole and the caller's offset is
left alone. eb-keep-logs, the one caller, rewinds the source after the
copy, which now does nothing; its tests pass against this change.
@HaoZeke
HaoZeke merged commit c592280 into main Nov 16, 2026
8 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant